ADC3669API

   1from samrat_api import Samrat
   2from time import sleep
   3from math import log
   4from typing import List
   5
   6
   7class ADC3669:
   8    def __init__(self, device_name, device_handle, sample_frequency):
   9        self.device_name = device_name
  10        self.device = device_handle
  11        self.fs = sample_frequency
  12        self.samrat = Samrat(device_handle, sample_frequency)
  13
  14    def reg_read(self, addr: int) -> int:
  15        """Reads the value stored in a register
  16
  17        Arguments:
  18            addr:
  19                The address of the desired register
  20
  21        Raises:
  22            None
  23
  24        Returns:
  25            The value of the register that is read back
  26        """
  27        return self.samrat.read(addr)
  28
  29    def reg_write(self, addr: int, value: int) -> None:
  30        """Writes a value into a register
  31
  32        Arguments:
  33            addr:
  34                The address of the desired register
  35            value:
  36                The value that is to be written to the register
  37
  38        Raises:
  39            None
  40
  41        Returns:
  42            None
  43        """
  44        self.samrat.write(addr, value)
  45
  46    def configure_ready(self) -> int:
  47        """Indicates the status of the internal fuse load after HW reset. The device should not be programmed before the fuse load is complete.
  48
  49        Arguments:
  50            None
  51
  52        Raises:
  53            None
  54
  55        Returns:
  56            Status of the fuse autoload.
  57
  58            - 0: Fuse autoload is incomplete, and the device should not be programmed
  59            - 1: Fuse autoload is complete, the device can be programmed
  60        """
  61        return self.samrat.GET_FUSE_LOAD_DONE()
  62
  63    def reset(self) -> None:
  64        """Resets the device. The register will self clear after reset.
  65
  66        Arguments:
  67            None
  68
  69        Raises:
  70            None
  71
  72        Returns:
  73            None
  74        """
  75        self.samrat.SET_SOFTWARE_RESET(1)
  76
  77    def global_powerdown(self, value: int) -> None:
  78        """Powers down the device.
  79
  80        Arguments:
  81            value: input value
  82                - 0: Normal Operation
  83                - 1: Powerdown
  84
  85        Raises:
  86            None
  87
  88        Returns:
  89            None
  90        """
  91        self.samrat.SET_GLOBAL_PDN(value)
  92
  93    def fast_powerdown_cha(self, value: int) -> None:
  94        """Puts channel A into a low power state that enables a fast wake time.
  95
  96        Arguments:
  97            value: input value
  98                - 0: Normal Operation
  99                - 1: Powerdown
 100
 101        Raises:
 102            None
 103
 104        Returns:
 105            None
 106        """
 107        self.samrat.SET_FAST_PDN_CH0(value)
 108
 109    def fast_powerdown_chb(self, state: int) -> None:
 110        """Puts channel B into a low power state that enables a fast wake time.
 111
 112        Arguments:
 113            value: input value
 114                - 0: Normal Operation
 115                - 1: Powerdown
 116
 117        Raises:
 118            None
 119
 120        Returns:
 121            None
 122        """
 123        self.samrat.SET_FAST_PDN_CH1(state)
 124
 125    def sysref_detect_clear(self, value: int) -> None:
 126        """resets the SYSREF DET flag
 127
 128        Arguments:
 129            value: input value
 130                - 0: Normal operation
 131                - 1: SYSREF DET flag gets reset
 132
 133        Raises:
 134            None
 135
 136        Returns:
 137            None
 138        """
 139        self.samrat.SET_SYSREF_DET_CLR(value)
 140
 141    def cha_termination(self, value: int) -> None:
 142        """Sets the internal termination on channel A.
 143
 144        Arguments:
 145            value: input value
 146                - 0: 100Ω differential termination
 147                - 1: 200Ω differential termination
 148
 149        Raises:
 150            None
 151
 152        Returns:
 153            None
 154        """
 155        self.samrat.SET_CH0_200_OHM_TERM(value)
 156
 157    def chb_termination(self, value: int) -> None:
 158        """Sets the internal termination on channel B.
 159
 160        Arguments:
 161            value: input value
 162                - 0: 100Ω differential termination
 163                - 1: 200Ω differential termination
 164
 165        Raises:
 166            None
 167
 168        Returns:
 169            None
 170        """
 171        self.samrat.SET_CH1_200_OHM_TERM(value)
 172
 173    def overrange_clear(self, value) -> None:
 174        """A transition from 0 to 2 clears the clears the sticky overrange bit.
 175
 176        Arguments:
 177            value: input value
 178                - 0: Normal operation
 179                - 2: Overrange bit is cleared
 180
 181        Raises:
 182            None
 183
 184        Returns:
 185            None
 186        """
 187        self.samrat.SET_DIG_OVR_CLEAR(value)
 188
 189    def overrange_sticky(self, value: int) -> None:
 190        """Makes the digital Overrange sticky.
 191
 192        Arguments:
 193            value: input value
 194                - 0: Digital OVR is non-sticky (updated based on overrange_length())
 195                - 1: Digital OVR is sticky (use overrange_clear() to reset)
 196
 197        Raises:
 198            None
 199
 200        Returns:
 201            None
 202        """
 203        self.samrat.SET_DIG_OVR_MODE(value)
 204
 205    def overrange_length(self, value: int) -> None:
 206        """Controls the Overrange pulse expansion. The expansion width is specified in terms of number of clock cycles.
 207
 208        Arguments:
 209            value: input value
 210                8-bit integer specifying the ovr pulse expansion in number of clock cycles
 211
 212        Raises:
 213            None
 214
 215        Returns:
 216            None
 217        """
 218        self.samrat.SET_DIG_OVR_WIDTH(value)
 219
 220    def lvds_termination(self, value: int) -> None:
 221        """Configures the LVDS termination resistance
 222
 223        Arguments:
 224            value: input value
 225                - 0: LVDS termination is 50Ω
 226                - 1: LVDS termination is 100Ω
 227
 228        Raises:
 229            None
 230
 231        Returns:
 232            None
 233        """
 234        self.samrat.SET_HUNDRED_OHM_TERM(value)
 235
 236    def lvds_half_swing(self, value: int) -> None:
 237        """Reduces LVDS output swing by 50% to reduce power consumption
 238
 239        Arguments:
 240            value: input value
 241                - 0: Normal output swing
 242                - 1: Reduced output swing
 243
 244        Raises:
 245            None
 246
 247        Returns:
 248            None
 249        """
 250        self.samrat.SET_LVDS_HALF_SWING_EN(value)
 251
 252    def data_rate(self, value: int) -> None:
 253        """This bit configures the parallel LVDS output interface. When only a single channel is output, SDR LVDS can be enabled.
 254
 255        Arguments:
 256            value: input value
 257                - 0: Dual Data Rate (DDR)
 258                - 1: Single Data Rate (SDR)
 259
 260        Raises:
 261            None
 262
 263        Returns:
 264            None
 265        """
 266        self.samrat.SET_SDR(value)
 267
 268    def swap_channels(self, value: int) -> None:
 269        """Internally swaps channel A and channel B.
 270
 271        Arguments:
 272            value: input value
 273                - 0: Normal operation
 274                - 1: Channel A and channel B are swapped
 275
 276        Raises:
 277            None
 278
 279        Returns:
 280            None
 281        """
 282        self.samrat.SET_SWAP_CHANNELS(value)
 283
 284    def lvds_data_invert(self, value) -> None:
 285        """Inverts the polarity of individual LVDS output lanes.
 286
 287        Arguments:
 288            lanes:
 289                Value to write to the register, where each bit represents as listed in the datasheet, and the values correspond to the following functions:
 290                - 0: Normal operation
 291                - 1: LVDS Lane is inverted
 292
 293        Raises:
 294            None
 295
 296        Returns:
 297            None
 298        """
 299        self.samrat.SET_LVDS_DATA_INV(value)
 300
 301    def lvds_powerdown(self, value: List[int]) -> None:
 302        """Powers down the individual LVDS output lanes and puts LVDS pins into high impedance state.
 303
 304        Arguments:
 305            value: input value
 306                Value to write to the register, where each bit represents as listed in the datasheet, and the values correspond to the following functions:
 307                - 0: Normal operation
 308                - 1: Powered down
 309
 310        Raises:
 311            None
 312
 313        Returns:
 314            None
 315        """
 316        self.samrat.SET_LVDS_DATA_PDN(value)
 317
 318    def fclk_duty_cycle(self, value: int) -> None:
 319        """Adjusts the Frame clock duty cycle.
 320        Arguments:
 321            value: input value
 322                - 0: FCLK stays high for one DCLK cycle at the beginning of the output sample
 323                - 1: FCLK stays high for 50% of the output sample
 324
 325        Raises:
 326            None
 327
 328        Returns:
 329            None
 330        """
 331        self.samrat.SET_ENABLE_50PER_DUTY_FCLK(value)
 332
 333    def fclk_disable(self, value: int) -> None:
 334        """Disables the output Frame clock.
 335
 336        Arguments:
 337            value: input value
 338                - 0: FCLK replaces the LSB data and is transmitted on DOUT0
 339                - 1: FCLK is disabled and the LSB data is transmitted on DOUT0.
 340
 341        Raises:
 342            None
 343
 344        Returns:
 345            None
 346        """
 347        self.samrat.SET_DISABLE_FRAME_INSERTION(value)
 348
 349    def lvds_mux_enable(self, value: int) -> None:
 350        """Enables use of the LVDS output mux
 351
 352        Arguments:
 353            value: input value
 354                - 0: LVDS Mux disabled
 355                - 1: LVDS Mux enabled
 356
 357        Raises:
 358            None
 359
 360        Returns:
 361            None
 362        """
 363        self.samrat.SET_LVDS_CROSS_BAR_MUX_EN(value)
 364
 365    def lvds_swap_edge(self, value: int) -> None:
 366        """Swaps the output data bits transmitted on rising and falling edge of DCLK.
 367
 368        Arguments:
 369            value: input value
 370                - 0: Normal operation
 371                - 1: Output bits on rising and falling edge are swapped.
 372
 373        Raises:
 374            None
 375
 376        Returns:
 377            None
 378        """
 379        self.samrat.SET_LVDS_SWAP_RISE_FALL(value)
 380
 381    def lvds_scrambling(self, value: int) -> None:
 382        """Controls the scrambling and LSB insertion configuration on the output data
 383
 384        Arguments:
 385            value: input value
 386                - 0: No scrambling, Defualt Operation
 387                - 1: Data is XOR'ed with a PRBS bit. This PRBS is inserted on the LSB position
 388                - 2: OVR is inserted on the LSB position
 389                - 3: OVR is inserted on the LSB+1 position
 390                - 4: Data is XOR'ed with a PRBS bit, and the PRBS is inserted on LSB+1 position
 391                - 5: OVR is inserted on LSB+1 position, PRBS is inseted on LSB position. Data is XOR'ed with PRBS
 392                - 6: OVR is inserted on LSB+2 position, PRBS is inseted on LSB+1 position. Data is XOR'ed with PRBS
 393
 394        Raises:
 395            None
 396
 397        Returns:
 398            None
 399        """
 400        self.samrat.SET_LVDS_DATA_DITH_MODE(value)
 401
 402    def dout0_mux(self, data: int) -> None:
 403        """Configures the digital data output on LVDS lane 0
 404
 405        Arguments:
 406            data:
 407                The internal digital data bus lane that is being mapped
 408
 409        Raises:
 410            None
 411
 412        Returns:
 413            None
 414        """
 415        self.samrat.SET_LANE0_MUX_SEL(data)
 416
 417    def dout1_mux(self, data: int) -> None:
 418        """Configures the digital data output on LVDS lane 1
 419
 420        Arguments:
 421            data:
 422                The internal digital data bus lane that is being mapped
 423
 424        Raises:
 425            None
 426
 427        Returns:
 428            None
 429        """
 430        self.samrat.SET_LANE1_MUX_SEL(data)
 431
 432    def dout2_mux(self, data: int) -> None:
 433        """Configures the digital data output on LVDS lane 2
 434
 435        Arguments:
 436            data:
 437                The internal digital data bus lane that is being mapped
 438
 439        Raises:
 440            None
 441
 442        Returns:
 443            None
 444        """
 445        self.samrat.SET_LANE2_MUX_SEL(data)
 446
 447    def dout3_mux(self, data: int) -> None:
 448        """Configures the digital data output on LVDS lane 3
 449
 450        Arguments:
 451            data:
 452                The internal digital data bus lane that is being mapped
 453
 454        Raises:
 455            None
 456
 457        Returns:
 458            None
 459        """
 460        self.samrat.SET_LANE3_MUX_SEL(data)
 461
 462    def dout4_mux(self, data: int) -> None:
 463        """Configures the digital data output on LVDS lane 4
 464
 465        Arguments:
 466            data:
 467                The internal digital data bus lane that is being mapped
 468
 469        Raises:
 470            None
 471
 472        Returns:
 473            None
 474        """
 475        self.samrat.SET_LANE4_MUX_SEL(data)
 476
 477    def dout5_mux(self, data: int) -> None:
 478        """Configures the digital data output on LVDS lane 5
 479
 480        Arguments:
 481            data:
 482                The internal digital data bus lane that is being mapped
 483
 484        Raises:
 485            None
 486
 487        Returns:
 488            None
 489        """
 490        self.samrat.SET_LANE5_MUX_SEL(data)
 491
 492    def dout6_mux(self, data: int) -> None:
 493        """Configures the digital data output on LVDS lane 6
 494
 495        Arguments:
 496            data:
 497                The internal digital data bus lane that is being mapped
 498
 499        Raises:
 500            None
 501
 502        Returns:
 503            None
 504        """
 505        self.samrat.SET_LANE6_MUX_SEL(data)
 506
 507    def dout7_mux(self, data: int) -> None:
 508        """Configures the digital data output on LVDS lane 7
 509
 510        Arguments:
 511            data:
 512                The internal digital data bus lane that is being mapped
 513
 514        Raises:
 515            None
 516
 517        Returns:
 518            None
 519        """
 520        self.samrat.SET_LANE7_MUX_SEL(data)
 521
 522    def dout8_mux(self, data: int) -> None:
 523        """Configures the digital data output on LVDS lane 8
 524
 525        Arguments:
 526            data:
 527                The internal digital data bus lane that is being mapped
 528
 529        Raises:
 530            None
 531
 532        Returns:
 533            None
 534        """
 535        self.samrat.SET_LANE8_MUX_SEL(data)
 536
 537    def dout9_mux(self, data: int) -> None:
 538        """Configures the digital data output on LVDS lane 9
 539
 540        Arguments:
 541            data:
 542                The internal digital data bus lane that is being mapped
 543
 544        Raises:
 545            None
 546
 547        Returns:
 548            None
 549        """
 550        self.samrat.SET_LANE9_MUX_SEL(data)
 551
 552    def dout10_mux(self, data: int) -> None:
 553        """Configures the digital data output on LVDS lane 10
 554
 555        Arguments:
 556            data:
 557                The internal digital data bus lane that is being mapped
 558
 559        Raises:
 560            None
 561
 562        Returns:
 563            None
 564        """
 565        self.samrat.SET_LANE10_MUX_SEL(data)
 566
 567    def dout11_mux(self, data: int) -> None:
 568        """Configures the digital data output on LVDS lane 11
 569
 570        Arguments:
 571            data:
 572                The internal digital data bus lane that is being mapped
 573
 574        Raises:
 575            None
 576
 577        Returns:
 578            None
 579        """
 580        self.samrat.SET_LANE11_MUX_SEL(data)
 581
 582    def dout12_mux(self, data: int) -> None:
 583        """Configures the digital data output on LVDS lane 12
 584
 585        Arguments:
 586            data:
 587                The internal digital data bus lane that is being mapped
 588
 589        Raises:
 590            None
 591
 592        Returns:
 593            None
 594        """
 595        self.samrat.SET_LANE12_MUX_SEL(data)
 596
 597    def dout13_mux(self, data: int) -> None:
 598        """Configures the digital data output on LVDS lane 13
 599
 600        Arguments:
 601            data:
 602                The internal digital data bus lane that is being mapped
 603
 604        Raises:
 605            None
 606
 607        Returns:
 608            None
 609        """
 610        self.samrat.SET_LANE13_MUX_SEL(data)
 611
 612    def dout14_mux(self, data: int) -> None:
 613        """Configures the digital data output on LVDS lane 14
 614
 615        Arguments:
 616            data:
 617                The internal digital data bus lane that is being mapped
 618
 619        Raises:
 620            None
 621
 622        Returns:
 623            None
 624        """
 625        self.samrat.SET_LANE14_MUX_SEL(data)
 626
 627    def dout15_mux(self, data: int) -> None:
 628        """Configures the digital data output on LVDS lane 15
 629
 630        Arguments:
 631            data:
 632                The internal digital data bus lane that is being mapped
 633
 634        Raises:
 635            None
 636
 637        Returns:
 638            None
 639        """
 640        self.samrat.SET_LANE15_MUX_SEL(data)
 641
 642    def high_fin(self, value: int) -> None:
 643        """Enable for best AC performance for input frequencies greater than 500 MHz
 644
 645        Arguments:
 646            value: input value
 647                - 0: Normal operation
 648                - 1: Performance optimized for input frequencies greater than 500 MHz
 649
 650        Raises:
 651            None
 652
 653        Returns:
 654            None
 655        """
 656        self.samrat.SET_DIS_ANA_NL_CORR(value)
 657
 658    def sysref_detect(self) -> int:
 659        """Indicates if a SYSREF signal is detected. Upon detection this bit stays high until it gets reset (0x102, D6) or a device reset is issued.
 660
 661        Arguments:
 662            None
 663
 664        Raises:
 665            None
 666
 667        Returns:
 668            Status of the Sysref signal
 669            
 670            - 0: No Sysref signal detected
 671            - 1: Sysref signal detected
 672        """
 673        return self.samrat.GET_SYSREF_DET()
 674
 675    def sysref_or(self) -> int:
 676        """Output of the five SYSREF XOR flags logically OR'ed together
 677
 678        Arguments:
 679            None
 680
 681        Raises:
 682            None
 683
 684        Returns:
 685            Status of the SYSREF flags OR'ed together
 686            
 687            - 0: No sysref flags raised
 688            - 1: One of the five XOR flags is raised
 689        """
 690        return self.samrat.GET_SYSREF_OR()
 691
 692    def sysref_xor(self) -> int:
 693        """XOR flags from the SYSREF window monitoring circuitry. 
 694        
 695        The sampling clock falling edge is used to capture the SYSREF signal.
 696        If a SYSREF signal transition happens within -60/+140 ps of the SYSREF capture, the appropriate XOR flag gets raised.
 697        These bits are updated on every SYSREF rising edge.
 698
 699        Arguments:
 700            None
 701
 702        Raises:
 703            None
 704
 705        Returns:
 706            List of 5 flags as follows
 707
 708            - X0: SYSREF leading sample clock by 20 to 60ps
 709            - X1: SYSREF leading sample clock by 20ps to 0ps or SYSREF lagging sample clock by 0 to 20ps
 710            - X2: SYSREF lagging sample clock by up to 20 to 60ps
 711            - X3: SYSREF lagging sample clock by 60 to 100ps
 712            - X4: SYSREF lagging sample clock by 100 to 140ps
 713
 714            With the corresponding values:
 715            - 0: Flag not raised
 716            - 1: Flag raised
 717        """
 718        return self.samrat.GET_SYSREF_XOR()
 719
 720    def gpio_config(self, value: int) -> None:
 721        """Configures the functionaliy of the two GPIO pins
 722
 723        Arguments:
 724            value: input value
 725            
 726        | Value  | GPIO 1              | GPIO 0              |
 727        |:------:|:-------------------:|:-------------------:|
 728        | 0      | NOT USED            | SYSREF              |
 729        | 3      | GLOBAL POWER DOWN   | SYSREF              |
 730        | 4      | EXTERNAL REFERENCE  | SYSREF              |
 731        | 5      | NCO SWITCH 1        | NCO SWITCH 0        |
 732        | 8      | NOT USED            | SYSREF              |
 733        | 9      | OVR CHB/CHA         | SYSREF              |
 734        | 10     | NOT USED            | GLOBAL POWER DOWN   |
 735        | 11     | OVR CHB/CHA         | GLOBAL POWER DOWN   |
 736        | 12     | OVR CHB             | OVR CHA             |
 737
 738        Raises:
 739            None
 740
 741        Returns:
 742            None
 743        """
 744        self.samrat.SET_GPIO_CONFIG(value)
 745
 746    def pattern_clk(self, value: int) -> None:
 747        """Controls the clock of the pattern signal generator.
 748
 749        Arguments:
 750            value: input value
 751                - 0: Normal operation
 752                - 1: Decimation CLK is used for the pattern generator
 753
 754        Raises:
 755            None
 756
 757        Returns:
 758            None
 759        """
 760        self.samrat.SET_PATTERN_CLK(value)
 761
 762    def test_pattern(self, value: int) -> None:
 763        """Controls the type of test pattern.
 764        
 765        The generated pattern is 20 bits wide. In 16 bit resolution mode, 16 MSBs of the pattern mode are sent out.
 766        In 32 bit resolution mode, 12 zeros are padded to the generated pattern and sent out.
 767
 768        Arguments:
 769            value: input value
 770                - 0: Test pattern is disabled
 771                - 1: Ramp pattern with a step of 1 (at 20 bit level, which is equivalent to 1/16 at 16 bit level)
 772                - 2: Ramp pattern with a step value set by CUSTOM PATTERN.
 773                - 3: Not used
 774                - 4: Static pattern set by CUSTOM PATTERN
 775                - 5: Pattern toggles between CUSTOM PATTERN and invert of CUSTOM PATTERN
 776                - 6: Pattern toggles between CUSTOM PATTERN and 0
 777
 778        Raises:
 779            None
 780
 781        Returns:
 782            None
 783        """
 784        self.samrat.SET_TEST_PATTERN_MODE(value)
 785
 786    def custom_pattern(self, value: int) -> None:
 787        """Controls the pattern generator. This controls different functions depending on the TEST PATTERN setting
 788
 789        Arguments:
 790            value:
 791                20-bit custom pattern data
 792
 793        Raises:
 794            None
 795
 796        Returns:
 797            None
 798        """
 799        # if value != 0:
 800        #     if not ((int(log(value, 2)) + 1) <= 20):
 801        #         raise Exception("Custom pattern value must be 20 bits long or less")
 802        self.samrat.SET_CUSTOM_PATTERN(value)
 803
 804    def digital_gain_cha(self, value: int) -> None:
 805        """Controls digital gain for channel A. Maximum gain is 6dB.
 806
 807        Arguments:
 808            value:
 809                Desired value to write into the register, where:
 810                Gain = (20 x log(1+(Value / 128)))
 811
 812        Raises:
 813            None
 814
 815        Returns:
 816            None
 817        """
 818        self.samrat.SET_CH0_PROG_GAIN(value)
 819
 820    def digital_gain_chb(self, value: int) -> None:
 821        """Controls digital gain for channel B. Maximum gain is 6dB.
 822
 823        Arguments:
 824            value:
 825                Desired value to write into the register, where:
 826                Gain = (20 x log(1+(Value / 128)))
 827
 828        Raises:
 829            None
 830
 831        Returns:
 832            None
 833        """
 834        self.samrat.SET_CH1_PROG_GAIN(value)
 835
 836    def sysref_mode(self, value: int) -> None:
 837        """Controls the global SYSREF mask
 838
 839        Arguments:
 840            value: input value
 841                - 0: Pass all SYSREF pulses
 842                - 1: Pass the first SYSREF pulse and gates subsequent pulses
 843                - 2: Gate all SYSREF pulses
 844                - 3: Issue new SYSREF pulse. The pulse is issued when the state transitions to 11
 845
 846        Raises:
 847            None
 848
 849        Returns:
 850            None
 851        """
 852        self.samrat.SET_SYSREF_MODE(value)
 853
 854    def lvds_sysref_mask(self, value: int) -> None:
 855        """Controls the SYSREF pulse going to the LVDS block.
 856
 857        Arguments:
 858            value: input value
 859                - 0: Pass all SYSREF pulses
 860                - 1: Pass the first SYSREF pulse and gates subsequent pulses
 861                - 2: Gate all SYSREF pulses
 862                - 3: Issue new SYSREF pulse. The pulse is issued when the state transitions to 11
 863
 864        Raises:
 865            None
 866
 867        Returns:
 868            None
 869        """
 870        self.samrat.SET_LVDS_SYSREF_MASK(value)
 871
 872    def ddc_sysref_mask(self, value: int) -> None:
 873        """Controls the SYSREF pulse of DDC block.
 874
 875        Arguments:
 876            value: input value
 877                - 0: Pass all SYSREF pulses
 878                - 1: Pass the first SYSREF pulse and gates subsequent pulses
 879                - 2: Gate all SYSREF pulses
 880                - 3: Issue new SYSREF pulse. The pulse is issued when the state transitions to 11
 881
 882        Raises:
 883            None
 884
 885        Returns:
 886            None
 887        """
 888        self.samrat.SET_DECIMATION_SYSREF_MASK(value)
 889
 890    def nco_sysref_mask(self, value: int) -> None:
 891        """Controls the SYSREF pulse of NCO block.
 892
 893        Arguments:
 894            value: input value
 895                - 0: Pass all SYSREF pulses
 896                - 1: Pass the first SYSREF pulse and gates subsequent pulses
 897                - 2: Gate all SYSREF pulses
 898                - 3: Issue new SYSREF pulse. The pulse is issued when the state transitions to 11
 899
 900        Raises:
 901            None
 902
 903        Returns:
 904            None
 905        """
 906        self.samrat.SET_NCO_SYSREF_MASK(value)
 907
 908    def timer_sysref_mask(self, value: int) -> None:
 909        """Controls the SYSREF pulse of TIMER block.
 910
 911        Arguments:
 912            value: input value
 913                - 0: Pass all SYSREF pulses
 914                - 1: Pass the first SYSREF pulse and gates subsequent pulses
 915                - 2: Gate all SYSREF pulses
 916                - 3: Issue new SYSREF pulse. The pulse is issued when the state transitions to 11
 917
 918        Raises:
 919            None
 920
 921        Returns:
 922            None
 923        """
 924        self.samrat.SET_TIMER_SYSREF_MASK(value)
 925
 926    def sysref_time_stamp(self, value: int) -> None:
 927        """Allows the SYSREF to be passed on the FRAME_INDICATOR lane. OVR_ON_LSB setting takes precedence
 928
 929        Arguments:
 930            value: input value
 931                - 0: Normal operation
 932                - 3: Pass sysref time stamp on the frame indicator lane
 933
 934        Raises:
 935            None
 936
 937        Returns:
 938            None
 939        """
 940        self.samrat.SET_SYSREF_TIME_STAMP(value)
 941
 942    def gain_override(self, value: int) -> None:
 943        """Controls 6dB gain setting of the DDC. The 6dB gain is applied in COMPLEX DDC mode by default. This will force 6 dB gain on the DDC output, irrespective of the DDC mode
 944
 945        Arguments:
 946            value: input value
 947                - 0: Normal operation
 948                - 2: Unity gain
 949                - 3: 6dB gain override
 950
 951        Raises:
 952            None
 953
 954        Returns:
 955            None
 956        """
 957        self.samrat.SET_SIX_DB_GAIN_OVERRIDE(value)
 958
 959    def complex_decimation(self, value: int) -> None:
 960        """Enables/disables complex decimation for all DDCs.
 961
 962        Arguments:
 963            value: input value
 964                - 0: Real Deciamtion
 965                - 1: Complex Decimation
 966
 967        Raises:
 968            None
 969
 970        Returns:
 971            None
 972        """
 973        self.samrat.SET_EN_COMPLEX_DDC(value)
 974
 975    def output_resolution(self, value: int) -> None:
 976        """Configures the output resolution for 16-bit or 32-bit
 977
 978        Arguments:
 979            value: input value
 980                - 0: 16-bit output resolution
 981                - 1: 32-bit output resolution
 982
 983        Raises:
 984            None
 985
 986        Returns:
 987            None
 988        """
 989        self.samrat.SET_OUTPUT_RESOLUTION(value)
 990
 991    def output_format(self, value: int) -> None:
 992        """Configures the output data format
 993
 994        Arguments:
 995            value: input value
 996                - 0: Output format is 2s complement
 997                - 1: Output format is offset binary
 998
 999        Raises:
1000            None
1001
1002        Returns:
1003            None
1004        """
1005        self.samrat.SET_OUTPUT_FORMAT(value)
1006
1007    def ddc0_mux(self, input: int) -> None:
1008        """Sets the input data source to decimation filter 0.
1009
1010        Arguments:
1011            ddc:
1012                The DDC for which the input data source is being configured
1013            input:
1014                Input to the DDC
1015                - 0: Channel A
1016                - 1: Channel B
1017                - 2: 2x Average ((ChA + ChB)/2)
1018                - 3: 2x Average ((ChA - ChB)/2)
1019
1020        Raises:
1021            None
1022
1023        Returns:
1024            None
1025        """
1026        self.samrat.SET_DDC0_MUX(input)
1027
1028    def ddc1_mux(self, input: int) -> None:
1029        """Sets the input data source to decimation filter 1.
1030
1031        Arguments:
1032            ddc:
1033                The DDC for which the input data source is being configured
1034            input:
1035                Input to the DDC
1036                - 0: Channel B
1037                - 1: Channel A
1038                - 2: 2x Average ((ChA + ChB)/2)
1039                - 3: 2x Average ((ChA - ChB)/2)
1040
1041        Raises:
1042            None
1043
1044        Returns:
1045            None
1046        """
1047        self.samrat.SET_DDC1_MUX(input)
1048
1049    def ddc2_mux(self, input: int) -> None:
1050        """Sets the input data source to decimation filter 2.
1051
1052        Arguments:
1053            ddc:
1054                The DDC for which the input data source is being configured
1055            input:
1056                Input to the DDC
1057                - 0: Channel A
1058                - 1: Channel B
1059                - 2: 2x Average ((ChA + ChB)/2)
1060                - 3: 2x Average ((ChA - ChB)/2)
1061
1062        Raises:
1063            None
1064
1065        Returns:
1066            None
1067        """
1068        self.samrat.SET_DDC2_MUX(input)
1069
1070    def ddc3_mux(self, input: int) -> None:
1071        """Sets the input data source to decimation filter 3.
1072
1073        Arguments:
1074            ddc:
1075                The DDC for which the input data source is being configured
1076            input:
1077                Input to the DDC
1078                - 0: Channel B
1079                - 1: Channel A
1080                - 2: 2x Average ((ChA + ChB)/2)
1081                - 3: 2x Average ((ChA - ChB)/2)
1082
1083        Raises:
1084            None
1085
1086        Returns:
1087            None
1088        """
1089        self.samrat.SET_DDC3_MUX(input)
1090
1091    def nco0_update(self, value: int) -> None:
1092        """Updates the four NCO frequencies of NCO0.
1093
1094        Arguments:
1095            value: input value
1096                - 0: Normal operation
1097                - 1: Update NCO0 frequencies
1098
1099        Raises:
1100            None
1101
1102        Returns:
1103            None
1104        """
1105        self.samrat.SET_NCO0_UPDATE(value)
1106
1107    def nco1_update(self, value: int) -> None:
1108        """Updates the four NCO frequencies of NCO1.
1109
1110        Arguments:
1111            value: input value
1112                - 0: Normal operation
1113                - 1: Update NCO1 frequencies
1114
1115        Raises:
1116            None
1117
1118        Returns:
1119            None
1120        """
1121        self.samrat.SET_NCO1_UPDATE(value)
1122
1123    def nco2_update(self, value: int) -> None:
1124        """Updates the four NCO frequencies of NCO2.
1125
1126        Arguments:
1127            value: input value
1128                - 0: Normal operation
1129                - 1: Update NCO2 frequencies
1130
1131        Raises:
1132            None
1133
1134        Returns:
1135            None
1136        """
1137        self.samrat.SET_NCO2_UPDATE(value)
1138
1139    def nco3_update(self, value: int) -> None:
1140        """Updates the four NCO frequencies of NCO3.
1141
1142        Arguments:
1143            value: input value
1144                - 0: Normal operation
1145                - 1: Update NCO3 frequencies
1146
1147        Raises:
1148            None
1149
1150        Returns:
1151            None
1152        """
1153        self.samrat.SET_NCO3_UPDATE(value)
1154
1155    def select_negative_image(self, value: int) -> None:
1156        """Controls the selection of the negative frequency image. Applicable only in Complex DDC mode.
1157
1158        Arguments:
1159            value: input value
1160                - 0: Normal operation
1161                - 1: Negative image
1162
1163        Raises:
1164            None
1165
1166        Returns:
1167            None
1168        """
1169        self.samrat.SET_NCO_SEL_NEG_IMAGE(value)
1170
1171    def nco_mode(self, value: int) -> None:
1172        """Configures the NCOs operating mode.
1173
1174        Arguments:
1175            value: input value
1176                - 0: Phase continuous
1177                - 1: Infinite phase coherent
1178
1179        Raises:
1180            None
1181
1182        Returns:
1183            None
1184        """
1185        self.samrat.SET_NCO_MODE(value)
1186
1187    def low_latency_enable(self, value: int) -> None:
1188        """Enables low latency mode by byapssing all digital features
1189
1190        Arguments:
1191            value: input value
1192                - 0: Normal Operation
1193                - 1: Low Latency Mode
1194
1195        Raises:
1196            None
1197
1198        Returns:
1199            None
1200        """
1201        self.samrat.SET_ENABLE_LOW_LATENCY(value)
1202
1203    def disable_nco_auto_update(self, value: int) -> None:
1204        """Disables the automatic update when switching the NCOs using GPIO pins
1205
1206        Arguments:
1207            value: input value
1208                - 0: Automatic update enabled
1209                - 1: Automatic update disabled
1210
1211        Raises:
1212            None
1213
1214        Returns:
1215            None
1216        """
1217        self.samrat.SET_DISABLE_NCO_AUTO_UPDATE(value)
1218
1219    def nco_select_enable(self, value: int) -> None:
1220        """This bit enables NCO frequency selection via SPI register 0x166 instead of GPIO pins.
1221
1222        Arguments:
1223            value: input value
1224                - 0: NCO Select via GPIO Pins
1225                - 1: NCO Select via SPI Write
1226
1227        Raises:
1228            None
1229
1230        Returns:
1231            None
1232        """
1233        self.samrat.SET_ENABLE_NCO_SEL(value)
1234
1235    def nco_common_update(self, value: int) -> None:
1236        """Updates the four NCO frequencies of all NCOs.
1237
1238        Arguments:
1239            value: input value
1240                - 0: Normal operation
1241                - 1: Update NCO frequencies
1242
1243        Raises:
1244            None
1245
1246        Returns:
1247            None
1248        """
1249        self.samrat.SET_NCO_COMMON_UPDATE(value)
1250
1251    def ddc0_nco_select(self, nco: int) -> None:
1252        """Selects which of the 4 frequencies is active for DDC0.
1253
1254        Arguments:
1255            nco:
1256                NCO word to set as the active frequency
1257
1258        Raises:
1259            None
1260
1261        Returns:
1262            None
1263        """
1264        self.samrat.SET_DDC0_NCO_SEL(nco)
1265
1266    def ddc1_nco_select(self, nco: int) -> None:
1267        """Selects which of the 4 frequencies is active for DDC1.
1268
1269        Arguments:
1270            nco:
1271                NCO word to set as the active frequency
1272
1273        Raises:
1274            None
1275
1276        Returns:
1277            None
1278        """
1279        self.samrat.SET_DDC1_NCO_SEL(nco)
1280
1281    def ddc2_nco_select(self, nco: int) -> None:
1282        """Selects which of the 4 frequencies is active for DDC2.
1283
1284        Arguments:
1285            nco:
1286                NCO word to set as the active frequency
1287
1288        Raises:
1289            None
1290
1291        Returns:
1292            None
1293        """
1294        self.samrat.SET_DDC2_NCO_SEL(nco)
1295
1296    def ddc3_nco_select(self, nco: int) -> None:
1297        """Selects which of the 4 frequencies is active for DDC3.
1298
1299        Arguments:
1300            nco:
1301                NCO word to set as the active frequency
1302
1303        Raises:
1304            None
1305
1306        Returns:
1307            None
1308        """
1309        self.samrat.SET_DDC3_NCO_SEL(nco)
1310
1311    def ddc0_decimation(self, value: int) -> None:
1312        """Sets the decimation filter factors for DDC0 when using unequal decimation factors.
1313
1314        Arguments:
1315            value:
1316                value to write to the register such that Decimation Factor = 2^value.
1317
1318        Raises:
1319            None
1320
1321        Returns:
1322            None
1323        """
1324        self.samrat.SET_DDC0_DECIMATION_MODE(value)
1325
1326    def ddc1_decimation(self, value: int) -> None:
1327        """Sets the decimation filter factors for DDC1 when using unequal decimation factors.
1328
1329        Arguments:
1330            value:
1331                value to write to the register such that Decimation Factor = 2^value.
1332
1333        Raises:
1334            None
1335
1336        Returns:
1337            None
1338        """
1339        self.samrat.SET_DDC1_DECIMATION_MODE(value)
1340
1341    def ddc2_decimation(self, value: int) -> None:
1342        """Sets the decimation filter factors for DDC2 when using unequal decimation factors.
1343
1344        Arguments:
1345            value:
1346                value to write to the register such that Decimation Factor = 2^value.
1347
1348        Raises:
1349            None
1350
1351        Returns:
1352            None
1353        """
1354        self.samrat.SET_DDC2_DECIMATION_MODE(value)
1355
1356    def ddc3_decimation(self, value: int) -> None:
1357        """Sets the decimation filter factors for DDC3 when using unequal decimation factors.
1358
1359        Arguments:
1360            value:
1361                value to write to the register such that Decimation Factor = 2^value.
1362
1363        Raises:
1364            None
1365
1366        Returns:
1367            None
1368        """
1369        self.samrat.SET_DDC3_DECIMATION_MODE(value)
1370
1371    def unequal_decimation(self, value: int) -> None:
1372        """Enables configuration of DDC0 thru DDC3 to have unequal decimation factors.
1373
1374        Arguments:
1375            value: input value
1376                - 0: Normal operation
1377                - 1: Unequal decimation factors enabled
1378
1379        Raises:
1380            None:
1381
1382        Returns:
1383            None
1384        """
1385        self.samrat.SET_SELECT_INDEPENDENT_DECIMATION(value)
1386
1387    def number_of_ddcs(self, value: int) -> None:
1388        """This register configures the # of active DDCs.
1389
1390        Arguments:
1391            value: input value
1392                - 0: Single DDC per channel (Total two DDCs are enabled)
1393                - 1: Dual DDCs per channel (Total 4 DDCs are enabled)
1394                - 2: Just one DDC is enabled (1 DDC is active)
1395                - 3: Dual DDC for a single channel (Total two DDCs are enabled)
1396
1397        Raises:
1398            None
1399
1400        Returns:
1401            None
1402        """
1403        lsb = value & 1
1404        msb = value >> 1
1405        self.samrat.SET_EN_DUAL_BAND(lsb)
1406        self.samrat.SET_DIS_DUAL_CHANNEL(msb)
1407
1408    def common_decimation(self, value: int) -> None:
1409        """Sets the decimation filter factor for all active DDCs.
1410
1411        Arguments:
1412            value:
1413                value to write to the register such that Decimation Factor = 2^value.
1414
1415        Raises:
1416            None
1417
1418        Returns:
1419            None
1420        """
1421        self.samrat.SET_COMMON_DECIMATION_MODE(value)
1422
1423    def update_nyqusit_zone(self, value: int) -> None:
1424        """Must be pulsed after the Nyquist zone if programmed.
1425        
1426        A 0 to 1 transition on this bit copies the NYQUIST ZONE field to an internal register.
1427
1428        Argument:
1429            value: input value
1430                - 0: Normal Operation
1431                - 1: Nyquist zone value is updated
1432
1433        Raises:
1434            None
1435
1436        Returns:
1437            None
1438        """
1439        self.samrat.SET_UPDATE_NYQUIST(value)
1440
1441    def nyquist_zone(self, value: int) -> None:
1442        """Sets the nyquist zone of operation.
1443        
1444        The internal calibration of the device depends on the NYQUIST ZONE of the signal being sampled.
1445        This field must be programmed based on the operating Nyquist zone.
1446
1447        Arguments:
1448            value:
1449                Operating nyquist zone (0 - 7)
1450
1451        Raises:
1452            None
1453
1454        Returns:
1455            None
1456        """
1457        self.samrat.SET_NYQUIST_ZONE(value)
1458
1459    def ddc0_nco_frequency0(self, value: int) -> None:
1460        """Configures the 48-bit NCO frequency word 0 of DDC0.
1461
1462        Arguments:
1463            value:
1464                Value to write to the NCO frequency word, such that:\n
1465                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1466                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1467
1468        Raises:
1469            None
1470
1471        Returns:
1472            None
1473        """
1474        self.samrat.SET_DDC0_NCO_FREQ0(value)
1475
1476    def ddc0_nco_frequency1(self, value: int) -> None:
1477        """Configures the 48-bit NCO frequency word 1 of DDC0.
1478
1479        Arguments:
1480            value:
1481                Value to write to the NCO frequency word, such that:\n
1482                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1483                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1484
1485        Raises:
1486            None
1487
1488        Returns:
1489            None
1490        """
1491        self.samrat.SET_DDC0_NCO_FREQ1(value)
1492
1493    def ddc0_nco_frequency2(self, value: int) -> None:
1494        """Configures the 48-bit NCO frequency word 2 of DDC0.
1495
1496        Arguments:
1497            value:
1498                Value to write to the NCO frequency word, such that:\n
1499                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1500                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1501
1502        Raises:
1503            None
1504
1505        Returns:
1506            None
1507        """
1508        self.samrat.SET_DDC0_NCO_FREQ2(value)
1509
1510    def ddc0_nco_frequency3(self, value: int) -> None:
1511        """Configures the 48-bit NCO frequency word 3 of DDC0.
1512
1513        Arguments:
1514            value:
1515                Value to write to the NCO frequency word, such that:\n
1516                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1517                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1518
1519        Raises:
1520            None
1521
1522        Returns:
1523            None
1524        """
1525        self.samrat.SET_DDC0_NCO_FREQ3(value)
1526
1527    def ddc1_nco_frequency0(self, value: int) -> None:
1528        """Configures the 48-bit NCO frequency word 0 of DDC1.
1529
1530        Arguments:
1531            value:
1532                Value to write to the NCO frequency word, such that:\n
1533                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1534                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1535
1536        Raises:
1537            None
1538
1539        Returns:
1540            None
1541        """
1542        self.samrat.SET_DDC1_NCO_FREQ0(value)
1543
1544    def ddc1_nco_frequency1(self, value: int) -> None:
1545        """Configures the 48-bit NCO frequency word 1 of DDC1.
1546
1547        Arguments:
1548            value:
1549                Value to write to the NCO frequency word, such that:\n
1550                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1551                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1552
1553        Raises:
1554            None
1555
1556        Returns:
1557            None
1558        """
1559        self.samrat.SET_DDC1_NCO_FREQ1(value)
1560
1561    def ddc1_nco_frequency2(self, value: int) -> None:
1562        """Configures the 48-bit NCO frequency word 2 of DDC1.
1563
1564        Arguments:
1565            value:
1566                Value to write to the NCO frequency word, such that:\n
1567                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1568                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1569
1570        Raises:
1571            None
1572
1573        Returns:
1574            None
1575        """
1576        self.samrat.SET_DDC1_NCO_FREQ2(value)
1577
1578    def ddc1_nco_frequency3(self, value: int) -> None:
1579        """Configures the 48-bit NCO frequency word 3 of DDC1.
1580
1581        Arguments:
1582            value:
1583                Value to write to the NCO frequency word, such that:\n
1584                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1585                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1586
1587        Raises:
1588            None
1589
1590        Returns:
1591            None
1592        """
1593        self.samrat.SET_DDC1_NCO_FREQ3(value)
1594
1595    def ddc2_nco_frequency0(self, value: int) -> None:
1596        """Configures the 48-bit NCO frequency word 0 of DDC2.
1597
1598        Arguments:
1599            value:
1600                Value to write to the NCO frequency word, such that:\n
1601                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1602                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1603
1604        Raises:
1605            None
1606
1607        Returns:
1608            None
1609        """
1610        self.samrat.SET_DDC2_NCO_FREQ0(value)
1611
1612    def ddc2_nco_frequency1(self, value: int) -> None:
1613        """Configures the 48-bit NCO frequency word 1 of DDC2.
1614
1615        Arguments:
1616            value:
1617                Value to write to the NCO frequency word, such that:\n
1618                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1619                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1620
1621        Raises:
1622            None
1623
1624        Returns:
1625            None
1626        """
1627        self.samrat.SET_DDC2_NCO_FREQ1(value)
1628
1629    def ddc2_nco_frequency2(self, value: int) -> None:
1630        """Configures the 48-bit NCO frequency word 2 of DDC2.
1631
1632        Arguments:
1633            value:
1634                Value to write to the NCO frequency word, such that:\n
1635                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1636                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1637
1638        Raises:
1639            None
1640
1641        Returns:
1642            None
1643        """
1644        self.samrat.SET_DDC2_NCO_FREQ2(value)
1645
1646    def ddc2_nco_frequency3(self, value: int) -> None:
1647        """Configures the 48-bit NCO frequency word 3 of DDC2.
1648
1649        Arguments:
1650            value:
1651                Value to write to the NCO frequency word, such that:\n
1652                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1653                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1654
1655        Raises:
1656            None
1657
1658        Returns:
1659            None
1660        """
1661        self.samrat.SET_DDC2_NCO_FREQ3(value)
1662
1663    def ddc3_nco_frequency0(self, value: int) -> None:
1664        """Configures the 48-bit NCO frequency word 0 of DDC3.
1665
1666        Arguments:
1667            value:
1668                Value to write to the NCO frequency word, such that:\n
1669                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1670                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1671
1672        Raises:
1673            None
1674
1675        Returns:
1676            None
1677        """
1678        self.samrat.SET_DDC3_NCO_FREQ0(value)
1679
1680    def ddc3_nco_frequency1(self, value: int) -> None:
1681        """Configures the 48-bit NCO frequency word 1 of DDC3.
1682
1683        Arguments:
1684            value:
1685                Value to write to the NCO frequency word, such that:\n
1686                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1687                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1688
1689        Raises:
1690            None
1691
1692        Returns:
1693            None
1694        """
1695        self.samrat.SET_DDC3_NCO_FREQ1(value)
1696
1697    def ddc3_nco_frequency2(self, value: int) -> None:
1698        """Configures the 48-bit NCO frequency word 2 of DDC3.
1699
1700        Arguments:
1701            value:
1702                Value to write to the NCO frequency word, such that:\n
1703                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1704                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1705
1706        Raises:
1707            None
1708
1709        Returns:
1710            None
1711        """
1712        self.samrat.SET_DDC3_NCO_FREQ2(value)
1713
1714    def ddc3_nco_frequency3(self, value: int) -> None:
1715        """Configures the 48-bit NCO frequency word 3 of DDC3.
1716
1717        Arguments:
1718            value:
1719                Value to write to the NCO frequency word, such that:\n
1720                When 0 > NCO frequency ≥ FS/2: value = fNCO * 2^48 / FS\n
1721                When -FS/2 ≤ NCO frequency < 0: value = (fNCO + FS) * 2^48 / FS
1722
1723        Raises:
1724            None
1725
1726        Returns:
1727            None
1728        """
1729        self.samrat.SET_DDC3_NCO_FREQ3(value)
1730
1731    def ddc0_nco_phase0(self, value: int) -> None:
1732        """Configures the starting phase for NCO Frequency 0 of DDC0
1733
1734        Arguments:
1735            value:
1736                Value to write to the NCO phase word, such that:
1737                value = 90° / Phase
1738        Raises:
1739            None
1740
1741        Returns:
1742            None
1743        """
1744        self.samrat.SET_DDC0_NCO_PHASE0(value)
1745
1746    def ddc0_nco_phase1(self, value: int) -> None:
1747        """Configures the starting phase for NCO Frequency 1 of DDC0
1748
1749        Arguments:
1750            value:
1751                Value to write to the NCO phase word, such that:
1752                value = 90° / Phase
1753        Raises:
1754            None
1755
1756        Returns:
1757            None
1758        """
1759        self.samrat.SET_DDC0_NCO_PHASE1(value)
1760
1761    def ddc0_nco_phase2(self, value: int) -> None:
1762        """Configures the starting phase for NCO Frequency 2 of DDC0
1763
1764        Arguments:
1765            value:
1766                Value to write to the NCO phase word, such that:
1767                value = 90° / Phase
1768        Raises:
1769            None
1770
1771        Returns:
1772            None
1773        """
1774        self.samrat.SET_DDC0_NCO_PHASE2(value)
1775
1776    def ddc0_nco_phase3(self, value: int) -> None:
1777        """Configures the starting phase for NCO Frequency 3 of DDC0
1778
1779        Arguments:
1780            value:
1781                Value to write to the NCO phase word, such that:
1782                value = 90° / Phase
1783        Raises:
1784            None
1785
1786        Returns:
1787            None
1788        """
1789        self.samrat.SET_DDC0_NCO_PHASE3(value)
1790
1791    def ddc1_nco_phase0(self, value: int) -> None:
1792        """Configures the starting phase for NCO Frequency 0 of DDC1
1793
1794        Arguments:
1795            value:
1796                Value to write to the NCO phase word, such that:
1797                value = 90° / Phase
1798        Raises:
1799            None
1800
1801        Returns:
1802            None
1803        """
1804        self.samrat.SET_DDC1_NCO_PHASE0(value)
1805
1806    def ddc1_nco_phase1(self, value: int) -> None:
1807        """Configures the starting phase for NCO Frequency 1 of DDC1
1808
1809        Arguments:
1810            value:
1811                Value to write to the NCO phase word, such that:
1812                value = 90° / Phase
1813        Raises:
1814            None
1815
1816        Returns:
1817            None
1818        """
1819        self.samrat.SET_DDC1_NCO_PHASE1(value)
1820
1821    def ddc1_nco_phase2(self, value: int) -> None:
1822        """Configures the starting phase for NCO Frequency 2 of DDC1
1823
1824        Arguments:
1825            value:
1826                Value to write to the NCO phase word, such that:
1827                value = 90° / Phase
1828        Raises:
1829            None
1830
1831        Returns:
1832            None
1833        """
1834        self.samrat.SET_DDC1_NCO_PHASE2(value)
1835
1836    def ddc1_nco_phase3(self, value: int) -> None:
1837        """Configures the starting phase for NCO Frequency 3 of DDC1
1838
1839        Arguments:
1840            value:
1841                Value to write to the NCO phase word, such that:
1842                value = 90° / Phase
1843        Raises:
1844            None
1845
1846        Returns:
1847            None
1848        """
1849        self.samrat.SET_DDC1_NCO_PHASE3(value)
1850
1851    def ddc2_nco_phase0(self, value: int) -> None:
1852        """Configures the starting phase for NCO Frequency 0 of DDC2
1853
1854        Arguments:
1855            value:
1856                Value to write to the NCO phase word, such that:
1857                value = 90° / Phase
1858        Raises:
1859            None
1860
1861        Returns:
1862            None
1863        """
1864        self.samrat.SET_DDC2_NCO_PHASE0(value)
1865
1866    def ddc2_nco_phase1(self, value: int) -> None:
1867        """Configures the starting phase for NCO Frequency 1 of DDC2
1868
1869        Arguments:
1870            value:
1871                Value to write to the NCO phase word, such that:
1872                value = 90° / Phase
1873        Raises:
1874            None
1875
1876        Returns:
1877            None
1878        """
1879        self.samrat.SET_DDC2_NCO_PHASE1(value)
1880
1881    def ddc2_nco_phase2(self, value: int) -> None:
1882        """Configures the starting phase for NCO Frequency 2 of DDC2
1883
1884        Arguments:
1885            value:
1886                Value to write to the NCO phase word, such that:
1887                value = 90° / Phase
1888        Raises:
1889            None
1890
1891        Returns:
1892            None
1893        """
1894        self.samrat.SET_DDC2_NCO_PHASE2(value)
1895
1896    def ddc2_nco_phase3(self, value: int) -> None:
1897        """Configures the starting phase for NCO Frequency 3 of DDC2
1898
1899        Arguments:
1900            value:
1901                Value to write to the NCO phase word, such that:
1902                value = 90° / Phase
1903        Raises:
1904            None
1905
1906        Returns:
1907            None
1908        """
1909        self.samrat.SET_DDC2_NCO_PHASE3(value)
1910
1911    def ddc3_nco_phase0(self, value: int) -> None:
1912        """Configures the starting phase for NCO Frequency 0 of DDC3
1913
1914        Arguments:
1915            value:
1916                Value to write to the NCO phase word, such that:
1917                value = 90° / Phase
1918        Raises:
1919            None
1920
1921        Returns:
1922            None
1923        """
1924        self.samrat.SET_DDC3_NCO_PHASE0(value)
1925
1926    def ddc3_nco_phase1(self, value: int) -> None:
1927        """Configures the starting phase for NCO Frequency 1 of DDC3
1928
1929        Arguments:
1930            value:
1931                Value to write to the NCO phase word, such that:
1932                value = 90° / Phase
1933        Raises:
1934            None
1935
1936        Returns:
1937            None
1938        """
1939        self.samrat.SET_DDC3_NCO_PHASE1(value)
1940
1941    def ddc3_nco_phase2(self, value: int) -> None:
1942        """Configures the starting phase for NCO Frequency 2 of DDC3
1943
1944        Arguments:
1945            value:
1946                Value to write to the NCO phase word, such that:
1947                value = 90° / Phase
1948        Raises:
1949            None
1950
1951        Returns:
1952            None
1953        """
1954        self.samrat.SET_DDC3_NCO_PHASE2(value)
1955
1956    def ddc3_nco_phase3(self, value: int) -> None:
1957        """Configures the starting phase for NCO Frequency 3 of DDC3
1958
1959        Arguments:
1960            value:
1961                Value to write to the NCO phase word, such that:
1962                value = 90° / Phase
1963        Raises:
1964            None
1965
1966        Returns:
1967            None
1968        """
1969        self.samrat.SET_DDC3_NCO_PHASE3(value)
1970
1971    def enable_dclk_divider(self, value: int) -> None:
1972        """Enables the Data Clock divider for higher decimation rates.
1973
1974        Arguments:
1975            value: input value
1976                - 0: DCLK divider is disabled. DCLK is equal to the Sample CLK
1977                - 1: DCLK divider is enabled. DCLK is divided down from Sample CLK
1978
1979        Raises:
1980            None
1981
1982        Returns:
1983            None
1984        """
1985        self.samrat.SET_DIG_CLK_DDC(value)
1986
1987    def dclk_powerdown(self, value: int) -> None:
1988        """Powers down the LVDS output clock.
1989
1990        Arguments:
1991            value: input value
1992                - 0: Normal operation
1993                - 1: Dclk powered down
1994
1995        Raises:
1996            None
1997
1998        Returns:
1999            None
2000        """
2001        self.samrat.SET_DCLK_PDN(value)
2002
2003    ######################################################################################################################################
2004    # ███╗   ███╗ █████╗  ██████╗██████╗  ██████╗ ███████╗
2005    # ████╗ ████║██╔══██╗██╔════╝██╔══██╗██╔═══██╗██╔════╝
2006    # ██╔████╔██║███████║██║     ██████╔╝██║   ██║███████╗
2007    # ██║╚██╔╝██║██╔══██║██║     ██╔══██╗██║   ██║╚════██║
2008    # ██║ ╚═╝ ██║██║  ██║╚██████╗██║  ██║╚██████╔╝███████║
2009    # ╚═╝     ╚═╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝
2010    ######################################################################################################################################
2011
2012    def pulse_overrange_clear(self) -> None:
2013        """Clears the Digital Overrange by pulsing a value of 2 on the OVR_CLR register field
2014
2015        Arguments:
2016            None
2017
2018        Raises:
2019            None
2020
2021        Returns:
2022            None
2023        """
2024        self.samrat.SET_DIG_OVR_CLEAR(0x0)
2025        sleep(0.1)
2026        self.samrat.SET_DIG_OVR_CLEAR(0x2)
2027        sleep(0.1)
2028        self.samrat.SET_DIG_OVR_CLEAR(0x0)
2029
2030    def invert_lvds_lanes(self, lanes: List[int]) -> None:
2031        """Inverts the polarity of individual LVDS output lanes.
2032
2033        Arguments:
2034            lanes:
2035                List of 16 lanes with the corresponding values:
2036                - 0: Polarity as shown in pin diagram.
2037                - 1: Polarity inverted
2038
2039        Raises:
2040            None
2041
2042        Returns:
2043            None
2044        """
2045        lanes = int("".join(map(str, lanes)), 2)
2046        self.samrat.SET_LVDS_DATA_INV(lanes)
2047
2048    def powerdown_lvds_lanes(self, lanes: List[int]) -> None:
2049        """Powers down the individual LVDS output lanes and puts LVDS pins into high impedance state.
2050
2051        Arguments:
2052            lanes:
2053                List of bits which enable or disable the LVDS lanes as follows
2054                - 0: Normal operation
2055                - 1: Powered down
2056
2057        Raises:
2058            None
2059
2060        Returns:
2061            None
2062        """
2063        lanes = int("".join(map(str, lanes)), 2)
2064        self.samrat.SET_LVDS_DATA_PDN(lanes)
2065
2066    def dout_mux(self, lane: int, data: int) -> None:
2067        """Configures the data bus assignments for each individual output lane
2068
2069        Arguments:
2070            lane:
2071                The DOUT output pin to be mapped to
2072            data:
2073                The internal digital data bus lane that is being mapped
2074
2075        Raises:
2076            None
2077
2078        Returns:
2079            None
2080        """
2081        if lane == 0:
2082            self.samrat.SET_LANE0_MUX_SEL(data)
2083        elif lane == 1:
2084            self.samrat.SET_LANE1_MUX_SEL(data)
2085        elif lane == 2:
2086            self.samrat.SET_LANE2_MUX_SEL(data)
2087        elif lane == 3:
2088            self.samrat.SET_LANE3_MUX_SEL(data)
2089        elif lane == 4:
2090            self.samrat.SET_LANE4_MUX_SEL(data)
2091        elif lane == 5:
2092            self.samrat.SET_LANE5_MUX_SEL(data)
2093        elif lane == 6:
2094            self.samrat.SET_LANE6_MUX_SEL(data)
2095        elif lane == 7:
2096            self.samrat.SET_LANE7_MUX_SEL(data)
2097        elif lane == 8:
2098            self.samrat.SET_LANE8_MUX_SEL(data)
2099        elif lane == 9:
2100            self.samrat.SET_LANE9_MUX_SEL(data)
2101        elif lane == 10:
2102            self.samrat.SET_LANE10_MUX_SEL(data)
2103        elif lane == 11:
2104            self.samrat.SET_LANE11_MUX_SEL(data)
2105        elif lane == 12:
2106            self.samrat.SET_LANE12_MUX_SEL(data)
2107        elif lane == 13:
2108            self.samrat.SET_LANE13_MUX_SEL(data)
2109        elif lane == 14:
2110            self.samrat.SET_LANE14_MUX_SEL(data)
2111        elif lane == 15:
2112            self.samrat.SET_LANE15_MUX_SEL(data)
2113
2114    def lvds_mirror_all(self, lane: int) -> None:
2115        """Mirrors all LVDS lanes to data of chosen lane
2116
2117        Arguments:
2118            lane:
2119                The desired lane data to mirror to all output lanes
2120
2121        Raises:
2122            None
2123
2124        Returns:
2125            None
2126        """
2127        for i in range(0, 16):
2128            self.dout_mux(i, lane)
2129
2130    def cha_digital_gain(self, value: int) -> None:
2131        """Controls digital gain for channel A. Maximum gain is 6dB.
2132
2133        Arguments:
2134            value:
2135                Desired gain value in dB
2136
2137        Raises:
2138            None
2139
2140        Returns:
2141            None
2142        """
2143        gain = 20 * log(1 + (value / 128), 10)
2144        self.samrat.SET_CH0_PROG_GAIN(gain)
2145
2146    def chb_digital_gain(self, value: int) -> None:
2147        """Controls digital gain for channel B. Maximum gain is 6dB.
2148
2149        Arguments:
2150            value:
2151                Desired gain value in dB
2152
2153        Raises:
2154            None
2155
2156        Returns:
2157            None
2158        """
2159        gain = 20 * log(1 + (value / 128), 10)
2160        self.samrat.SET_CH1_PROG_GAIN(gain)
2161
2162    def sysref_pulse(self) -> None:
2163        """Pulses the sysref signal
2164
2165        Arguments:
2166            None
2167
2168        Raises:
2169            None
2170
2171        Returns:
2172            None
2173        """
2174        self.sysref_mode(0)
2175        sleep(0.1)
2176        self.sysref_mode(3)
2177        sleep(0.1)
2178        self.sysref_mode(0)
2179
2180    def ddc_input_source(self, ddc: int, input: int) -> None:
2181        """Sets the input data source to each of the decimation filters.
2182
2183        Arguments:
2184            ddc:
2185                The DDC for which the input data source is being configured
2186            input:
2187                Input to the DDC
2188                - 0: Channel A
2189                - 1: Channel B
2190                - 2: 2x Average ((ChA + ChB)/2)
2191                - 3: 2x Average ((ChA - ChB)/2)
2192
2193        Raises:
2194            None
2195
2196        Returns:
2197            None
2198        """
2199        if ddc == 0:
2200            self.samrat.SET_DDC0_MUX(input)
2201        elif ddc == 1:
2202            if input == 0:
2203                input = 1
2204            elif input == 1:
2205                input = 0
2206            self.samrat.SET_DDC1_MUX(input)
2207        elif ddc == 2:
2208            self.samrat.SET_DDC2_MUX(input)
2209        elif ddc == 3:
2210            if input == 0:
2211                input = 1
2212            elif input == 1:
2213                input = 0
2214            self.samrat.SET_DDC3_MUX(input)
2215
2216    def nco_update(self, nco: int) -> None:
2217        """Updates the frequency of the selected NCO by pulsing a value of 1 on the corresponding NCO_UPDATE field
2218
2219        Arguments:
2220            nco:
2221                NCO that is being configured
2222
2223        Raises:
2224            None
2225
2226        Returns:
2227            None
2228        """
2229        if nco == 0:
2230            self.samrat.SET_NCO0_UPDATE(0)
2231            sleep(0.1)
2232            self.samrat.SET_NCO0_UPDATE(1)
2233            sleep(0.1)
2234            self.samrat.SET_NCO0_UPDATE(1)
2235        elif nco == 1:
2236            self.samrat.SET_NCO1_UPDATE(0)
2237            sleep(0.1)
2238            self.samrat.SET_NCO1_UPDATE(1)
2239            sleep(0.1)
2240            self.samrat.SET_NCO1_UPDATE(1)
2241        elif nco == 2:
2242            self.samrat.SET_NCO2_UPDATE(0)
2243            sleep(0.1)
2244            self.samrat.SET_NCO2_UPDATE(1)
2245            sleep(0.1)
2246            self.samrat.SET_NCO2_UPDATE(1)
2247        elif nco == 3:
2248            self.samrat.SET_NCO3_UPDATE(0)
2249            sleep(0.1)
2250            self.samrat.SET_NCO3_UPDATE(1)
2251            sleep(0.1)
2252            self.samrat.SET_NCO3_UPDATE(1)
2253
2254    def nco_update_common(self) -> None:
2255        """Updates the four NCO frequencies of all NCOs by pulsing a vlaue of 1 on the NCO_COMMON_UPDATE field
2256
2257        Arguments:
2258            None
2259
2260        Raises:
2261            None
2262
2263        Returns:
2264            None
2265        """
2266        self.samrat.SET_NCO_COMMON_UPDATE(0)
2267        sleep(0.1)
2268        self.samrat.SET_NCO_COMMON_UPDATE(1)
2269        sleep(0.1)
2270        self.samrat.SET_NCO_COMMON_UPDATE(0)
2271
2272    def ddc_nco_select(self, ddc: int, nco: int) -> None:
2273        """These bits select which of the 4 frequencies are active in the respective DDCs/NCOs.
2274
2275        Arguments:
2276            ddc:
2277                DDC of which to configure the nco frequency
2278            nco:
2279                NCO frequency to set as the active frequency
2280
2281        Raises:
2282            None
2283
2284        Returns:
2285            None
2286        """
2287        if ddc == 0:
2288            self.samrat.SET_DDC0_NCO_SEL(nco)
2289        elif ddc == 1:
2290            self.samrat.SET_DDC1_NCO_SEL(nco)
2291        elif ddc == 2:
2292            self.samrat.SET_DDC2_NCO_SEL(nco)
2293        elif ddc == 3:
2294            self.samrat.SET_DDC3_NCO_SEL(nco)
2295
2296    def ddc_decimation_factor(self, ddc: int, factor: int) -> None:
2297        """Sets the decimation factor for each DDC
2298
2299        Arguments:
2300            ddc:
2301                The DDC for which the decimation factor is being configured
2302            factor:
2303                Desired decimation factor
2304
2305        Raises:
2306            None
2307
2308        Returns:
2309            None
2310        """
2311        if factor == 0:
2312            n = factor
2313        else:
2314            n = int(log(factor, 2))
2315
2316        self.samrat.SET_SELECT_INDEPENDENT_DECIMATION(
2317            1
2318        )  # Configure for different decimation factors for each DDC
2319
2320        if ddc == 0:
2321            self.samrat.SET_DDC0_DECIMATION_MODE(n)
2322        elif ddc == 1:
2323            self.samrat.SET_DDC1_DECIMATION_MODE(n)
2324        elif ddc == 2:
2325            self.samrat.SET_DDC2_DECIMATION_MODE(n)
2326        elif ddc == 3:
2327            self.samrat.SET_DDC3_DECIMATION_MODE(n)
2328
2329    def decimation_factor_common(self, factor: int) -> None:
2330        """Enables decimation for all DDCs and sets the common decimation factor for all DDCs
2331
2332        Arguments:
2333            factor:
2334                Desired decimation factor
2335
2336        Raises:
2337            None
2338
2339        Returns:
2340            None
2341        """
2342        if factor == 0:
2343            n = factor
2344        else:
2345            n = int(log(factor, 2))
2346
2347        self.samrat.SET_SELECT_INDEPENDENT_DECIMATION(
2348            0
2349        )  # Configure for common decimation factors for all DDCs
2350        self.samrat.SET_COMMON_DECIMATION_MODE(n)
2351
2352    def ddc_nco_frequency(self, ddc: int, nco: int, freq: int) -> None:
2353        """Configures the 48-bit frequency words for the four DDCs/NCOs.
2354
2355        Arguments:
2356            ddc:
2357                DDC of which the frequency is being configured
2358            nco:
2359                NCO frequency which is being configured (0-3)
2360            freq:
2361                Desired frequency
2362
2363        Raises:
2364            None
2365
2366        Returns:
2367            None
2368        """
2369        if freq > 0:
2370            nco_word = int(
2371                freq * (2**48) / self.fs
2372            )  # Formula for calulating this value is in the datasheet
2373        else:
2374            nco_word = int(
2375                ((self.samrat.fs + freq) * (2**48) / self.fs) - 1
2376            )  # Formula for calulating this value is in the datasheet
2377
2378        if ddc == 0:
2379            if nco == 0:
2380                self.samrat.SET_DDC0_NCO_FREQ0(nco_word)
2381            elif nco == 1:
2382                self.samrat.SET_DDC0_NCO_FREQ1(nco_word)
2383            elif nco == 2:
2384                self.samrat.SET_DDC0_NCO_FREQ2(nco_word)
2385            elif nco == 3:
2386                self.samrat.SET_DDC0_NCO_FREQ3(nco_word)
2387        elif ddc == 1:
2388            if nco == 0:
2389                self.samrat.SET_DDC1_NCO_FREQ0(nco_word)
2390            elif nco == 1:
2391                self.samrat.SET_DDC1_NCO_FREQ1(nco_word)
2392            elif nco == 2:
2393                self.samrat.SET_DDC1_NCO_FREQ2(nco_word)
2394            elif nco == 3:
2395                self.samrat.SET_DDC1_NCO_FREQ3(nco_word)
2396        elif ddc == 2:
2397            if nco == 0:
2398                self.samrat.SET_DDC2_NCO_FREQ0(nco_word)
2399            elif nco == 1:
2400                self.samrat.SET_DDC2_NCO_FREQ1(nco_word)
2401            elif nco == 2:
2402                self.samrat.SET_DDC2_NCO_FREQ2(nco_word)
2403            elif nco == 3:
2404                self.samrat.SET_DDC2_NCO_FREQ3(nco_word)
2405        elif ddc == 3:
2406            if nco == 0:
2407                self.samrat.SET_DDC3_NCO_FREQ0(nco_word)
2408            elif nco == 1:
2409                self.samrat.SET_DDC3_NCO_FREQ1(nco_word)
2410            elif nco == 2:
2411                self.samrat.SET_DDC3_NCO_FREQ2(nco_word)
2412            elif nco == 3:
2413                self.samrat.SET_DDC3_NCO_FREQ3(nco_word)
2414
2415    def ddc_nco_phase(self, ddc: int, nco: int, phase: int) -> None:
2416        """Configure the starting phase of the frequency for the DDCs/NCOs. The phase value is: 90° / <16-bit register>
2417
2418        Arguments:
2419            ddc:
2420                DDC of which the phase is being configured
2421            nco:
2422                NCO of which the phase is being configured
2423            phase:
2424                desired phase in degrees
2425
2426        Raises:
2427            None
2428
2429        Returns:
2430            None
2431        """
2432        if phase == 0:
2433            phaseval = 0
2434        else:
2435            phaseval = int(90 / phase)
2436
2437        if ddc == 0:
2438            if nco == 0:
2439                self.samrat.SET_DDC0_NCO_PHASE0(phaseval)
2440            elif nco == 1:
2441                self.samrat.SET_DDC0_NCO_PHASE1(phaseval)
2442            elif nco == 2:
2443                self.samrat.SET_DDC0_NCO_PHASE2(phaseval)
2444            elif nco == 3:
2445                self.samrat.SET_DDC0_NCO_PHASE3(phaseval)
2446        elif ddc == 1:
2447            if nco == 0:
2448                self.samrat.SET_DDC0_NCO_PHASE0(phaseval)
2449            elif nco == 1:
2450                self.samrat.SET_DDC1_NCO_PHASE1(phaseval)
2451            elif nco == 2:
2452                self.samrat.SET_DDC2_NCO_PHASE2(phaseval)
2453            elif nco == 3:
2454                self.samrat.SET_DDC3_NCO_PHASE3(phaseval)
2455        elif ddc == 2:
2456            if nco == 0:
2457                self.samrat.SET_DDC0_NCO_PHASE0(phaseval)
2458            elif nco == 1:
2459                self.samrat.SET_DDC1_NCO_PHASE1(phaseval)
2460            elif nco == 2:
2461                self.samrat.SET_DDC2_NCO_PHASE2(phaseval)
2462            elif nco == 3:
2463                self.samrat.SET_DDC3_NCO_PHASE3(phaseval)
2464        elif ddc == 3:
2465            if nco == 0:
2466                self.samrat.SET_DDC0_NCO_PHASE0(phaseval)
2467            elif nco == 1:
2468                self.samrat.SET_DDC1_NCO_PHASE1(phaseval)
2469            elif nco == 2:
2470                self.samrat.SET_DDC2_NCO_PHASE2(phaseval)
2471            elif nco == 3:
2472                self.samrat.SET_DDC3_NCO_PHASE3(phaseval)
2473
2474    def read_all_regs(self) -> None:
2475        """Reads all registers for configuration debug purposes.
2476
2477        Arguments:
2478            None
2479
2480        Raises:
2481            None
2482
2483        Returns:
2484            None
2485        """
2486        self.samrat.debugReadback()